package operateur;

/**
 * Interface definition : GestionUtilisateur
 * 
 * @author OpenORB Compiler
 */
public class _GestionUtilisateurStub extends org.omg.CORBA.portable.ObjectImpl
        implements GestionUtilisateur
{
    static final String[] _ids_list =
    {
        "IDL:operateur/GestionUtilisateur:1.0"
    };

    public String[] _ids()
    {
     return _ids_list;
    }

    private final static Class _opsClass = operateur.GestionUtilisateurOperations.class;

    /**
     * Operation authentifierClientMobile
     */
    public operateur.UtilisateurAffiche authentifierClientMobile(String idUtilisateur, String mdpSaisie, operateur.ClientMobile cm)
        throws operateur.Err_Authentification
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("authentifierClientMobile",true);
                    operateur.identHelper.write(_output,idUtilisateur);
                    operateur.mdpHelper.write(_output,mdpSaisie);
                    operateur.ClientMobileHelper.write(_output,cm);
                    _input = this._invoke(_output);
                    operateur.UtilisateurAffiche _arg_ret = operateur.UtilisateurAfficheHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_AuthentificationHelper.id()))
                    {
                        throw operateur.Err_AuthentificationHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("authentifierClientMobile",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.authentifierClientMobile( idUtilisateur,  mdpSaisie,  cm);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation authentifierTransporteurMobile
     */
    public operateur.UtilisateurAffiche authentifierTransporteurMobile(String idUtilisateur, String mdpSaisie, operateur.TransporteurMobile tm)
        throws operateur.Err_Authentification
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("authentifierTransporteurMobile",true);
                    operateur.identHelper.write(_output,idUtilisateur);
                    operateur.mdpHelper.write(_output,mdpSaisie);
                    operateur.TransporteurMobileHelper.write(_output,tm);
                    _input = this._invoke(_output);
                    operateur.UtilisateurAffiche _arg_ret = operateur.UtilisateurAfficheHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_AuthentificationHelper.id()))
                    {
                        throw operateur.Err_AuthentificationHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("authentifierTransporteurMobile",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.authentifierTransporteurMobile( idUtilisateur,  mdpSaisie,  tm);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation authentifierStation
     */
    public operateur.UtilisateurAffiche authentifierStation(String idUtilisateur, String mdpSaisie)
        throws operateur.Err_Authentification
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("authentifierStation",true);
                    operateur.identHelper.write(_output,idUtilisateur);
                    operateur.mdpHelper.write(_output,mdpSaisie);
                    _input = this._invoke(_output);
                    operateur.UtilisateurAffiche _arg_ret = operateur.UtilisateurAfficheHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_AuthentificationHelper.id()))
                    {
                        throw operateur.Err_AuthentificationHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("authentifierStation",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.authentifierStation( idUtilisateur,  mdpSaisie);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation getTransporteur
     */
    public String[] getTransporteur()
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("getTransporteur",true);
                    _input = this._invoke(_output);
                    String[] _arg_ret = operateur.listTransporteurHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("getTransporteur",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.getTransporteur();
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation getClient
     */
    public String[] getClient()
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("getClient",true);
                    _input = this._invoke(_output);
                    String[] _arg_ret = operateur.listClientHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("getClient",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.getClient();
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation getZoneUtilisateur
     */
    public String getZoneUtilisateur(String idUtilisateur)
        throws operateur.Err_id
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("getZoneUtilisateur",true);
                    operateur.identHelper.write(_output,idUtilisateur);
                    _input = this._invoke(_output);
                    String _arg_ret = operateur.zoneHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_idHelper.id()))
                    {
                        throw operateur.Err_idHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("getZoneUtilisateur",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.getZoneUtilisateur( idUtilisateur);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation getIorTransporteur
     */
    public operateur.TransporteurMobile getIorTransporteur(String idTransporteur)
        throws operateur.Err_id
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("getIorTransporteur",true);
                    operateur.identHelper.write(_output,idTransporteur);
                    _input = this._invoke(_output);
                    operateur.TransporteurMobile _arg_ret = operateur.TransporteurMobileHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_idHelper.id()))
                    {
                        throw operateur.Err_idHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("getIorTransporteur",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.getIorTransporteur( idTransporteur);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation getIorClient
     */
    public operateur.ClientMobile getIorClient(String idClient)
        throws operateur.Err_id
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("getIorClient",true);
                    operateur.identHelper.write(_output,idClient);
                    _input = this._invoke(_output);
                    operateur.ClientMobile _arg_ret = operateur.ClientMobileHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    if (_exception_id.equals(operateur.Err_idHelper.id()))
                    {
                        throw operateur.Err_idHelper.read(_exception.getInputStream());
                    }

                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("getIorClient",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.getIorClient( idClient);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

    /**
     * Operation adherer
     */
    public operateur.Rep_Adhesion adherer(String nomUtilisateur, String prenomUtilisateur, String adrUtilisateur, String mdpUtilisateur, String cptUtilisateur)
    {
        while(true)
        {
            if (!this._is_local())
            {
                org.omg.CORBA.portable.InputStream _input = null;
                try
                {
                    org.omg.CORBA.portable.OutputStream _output = this._request("adherer",true);
                    operateur.nomHelper.write(_output,nomUtilisateur);
                    operateur.prenomHelper.write(_output,prenomUtilisateur);
                    operateur.adresseHelper.write(_output,adrUtilisateur);
                    operateur.mdpHelper.write(_output,mdpUtilisateur);
                    operateur.infoPaiementHelper.write(_output,cptUtilisateur);
                    _input = this._invoke(_output);
                    operateur.Rep_Adhesion _arg_ret = operateur.Rep_AdhesionHelper.read(_input);
                    return _arg_ret;
                }
                catch(org.omg.CORBA.portable.RemarshalException _exception)
                {
                    continue;
                }
                catch(org.omg.CORBA.portable.ApplicationException _exception)
                {
                    String _exception_id = _exception.getId();
                    throw new org.omg.CORBA.UNKNOWN("Unexpected User Exception: "+ _exception_id);
                }
                finally
                {
                    this._releaseReply(_input);
                }
            }
            else
            {
                org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke("adherer",_opsClass);
                if (_so == null)
                   continue;
                operateur.GestionUtilisateurOperations _self = (operateur.GestionUtilisateurOperations) _so.servant;
                try
                {
                    return _self.adherer( nomUtilisateur,  prenomUtilisateur,  adrUtilisateur,  mdpUtilisateur,  cptUtilisateur);
                }
                finally
                {
                    _servant_postinvoke(_so);
                }
            }
        }
    }

}
